C!T ROM 3/ct-rom iiib.zip/ct-rom iiib/WINDOWS/DIVERSEN/WINE02BX/EMACS.4

Text File | 1993-03-28 | 45KB | 1,070 lines

Info file ../info/emacs, produced by Makeinfo, -*- Text -*- from input
file lemacs.tex.

   This file documents the GNU Emacs editor.

   Copyright (C) 1985, 1986, 1988 Richard M. Stallman.  Copyright (C)
1991, 1992 Lucid, Inc.

   Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "The GNU Manifesto", "Distribution" and "GNU
General Public License" are included exactly as in the original, and
provided that the entire resulting derived work is distributed under
the terms of a permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "The GNU Manifesto",
"Distribution" and "GNU General Public License" may be included in a
translation approved by the author instead of in the original English.


File: emacs,  Node: Killing,  Next: Yanking,  Prev: Mark,  Up: Top

Deletion and Killing
====================

   Most commands which erase text from the buffer save it. You can get
the text back if you change your mind, or you can move or copy it to
other parts of the buffer.  Commands which erase text and save it in
the kill ring are known as "kill" commands.  Some other commands erase
text but do not save it; they are known as "delete" commands.  (This
distinction is made only for erasing text in the buffer.)

   The commands' names and individual descriptions use the words
`kill' and `delete' to indicate what they do.  If you perform a kill
or delete command by mistake, use the `C-x u' (`undo') command to undo
it (*note Undo::.). The delete commands include `C-d' (`delete-char')
and DEL (`delete-backward-char'), which delete only one character at a
time, and those commands that delete only spaces or newlines.
Commands that can destroy significant amounts of nontrivial data
usually kill.

Deletion
--------

`C-d'
     Delete next character (`delete-char').

`DEL'
     Delete previous character (`delete-backward-char').

`M-\'
     Delete spaces and tabs around point (`delete-horizontal-space').

`M-SPC'
     Delete spaces and tabs around point, leaving one space
     (`just-one-space').

`C-x C-o'
     Delete blank lines around the current line (`delete-blank-lines').

`M-^'
     Join two lines by deleting the intervening newline, and any
     indentation following it (`delete-indentation').

   The most basic delete commands are `C-d' (`delete-char') and DEL
(`delete-backward-char').  `C-d' deletes the character after point,
the one the cursor is "on top of".  Point doesn't move.  DEL deletes
the character before the cursor, and moves point back.  You can delete
newlines like any other characters in the buffer; deleting a newline
joins two lines.  Actually, `C-d' and DEL aren't always delete
commands; if you give them an argument, they kill instead, since they
can erase more than one character this way.

   The other delete commands delete only formatting characters: spaces,
tabs and newlines.  `M-\' (`delete-horizontal-space') deletes all
spaces and tab characters before and after point.  `M-SPC'
(`just-one-space') does the same but leaves a single space after
point, regardless of the number of spaces that existed previously
(even zero).

   `C-x C-o' (`delete-blank-lines') deletes all blank lines after the
current line. If the current line is blank, it deletes all blank lines
preceding the current line as well as leaving one blank line, the
current line.  `M-^' (`delete-indentation') joins the current line and
the previous line, or the current line and the next line if given an
argument, by deleting a newline and all surrounding spaces, possibly
leaving a single space.  *Note M-^: Indentation.

Killing by Lines
----------------

`C-k'
     Kill rest of line or one or more lines (`kill-line').

   The simplest kill command is `C-k'.  If given at the beginning of a
line, it kills all the text on the line, leaving the line blank.  If
given on a blank line, the blank line disappears.  As a consequence, a
line disappears completely if you go to the front of a non-blank line
and type `C-k' twice.

   More generally, `C-k' kills from point up to the end of the line,
unless it is at the end of a line.  In that case, it kills the newline
following the line, thus merging the next line into the current one.
Emacs ignores invisible spaces and tabs at the end of the line when
deciding which case applies: if point appears to be at the end of the
line, you can be sure the newline will be killed.

   If you give `C-k' a positive argument, it kills that many lines and
the newlines that follow them (however, text on the current line
before point is not killed).  With a negative argument, `C-k' kills
back to a number of line beginnings.  An argument of -2 means kill
back to the second line beginning.  If point is at the beginning of a
line, that line beginning doesn't count, so `C-u - 2 C-k' with point
at the front of a line kills the two previous lines.

   `C-k' with an argument of zero kills all the text before point on
the current line.

Other Kill Commands
-------------------

`C-w'
     Kill region (from point to the mark) (`kill-region').  *Note
     Words::.

`M-d'
     Kill word (`kill-word').

`M-DEL'
     Kill word backwards (`backward-kill-word').

`C-x DEL'
     Kill back to beginning of sentence (`backward-kill-sentence').
     *Note Sentences::.

`M-k'
     Kill to end of sentence (`kill-sentence').

`C-M-k'
     Kill sexp (`kill-sexp').  *Note Lists::.

`M-z CHAR'
     Kill up to next occurrence of CHAR (`zap-to-char').

   `C-w' (`kill-region') is a very general kill command; it kills
everything between point and the mark. You can use this command to
kill any contiguous sequence of characters by first setting the mark at
one end of a sequence of characters, then going to the other end and
typing `C-w'.

   A convenient way of killing is combined with searching: `M-z'
(`zap-to-char') reads a character and kills from point up to (but not
including) the next occurrence of that character in the buffer.  If
there is no next occurrence, killing goes to the end of the buffer.  A
numeric argument acts as a repeat count.  A negative argument means to
search backward and kill text before point.

   Other syntactic units can be killed: words, with `M-DEL' and `M-d'
(*note Words::.); sexps, with `C-M-k' (*note Lists::.); and sentences,
with `C-x DEL' and `M-k' (*note Sentences::.).


File: emacs,  Node: Yanking,  Next: Using X Selections,  Prev: Killing,  Up: Top

Yanking
=======

   "Yanking" means getting back text which was killed. Some systems
call this "pasting".  The usual way to move or copy text is to kill it
and then yank it one or more times.

`C-y'
     Yank last killed text (`yank').

`M-y'
     Replace re-inserted killed text with the previously killed text
     (`yank-pop').

`M-w'
     Save region as last killed text without actually killing it
     (`copy-region-as-kill').

`C-M-w'
     Append next kill to last batch of killed text
     (`append-next-kill').

* Menu:

* Kill Ring::       Where killed text is stored.  Basic yanking.
* Appending Kills:: Several kills in a row all yank together.
* Earlier Kills::   Yanking something killed some time ago.


File: emacs,  Node: Kill Ring,  Next: Appending Kills,  Prev: Yanking,  Up: Yanking

The Kill Ring
-------------

   All killed text is recorded in the "kill ring", a list of blocks of
text that have been killed.  There is only one kill ring, used in all
buffers, so you can kill text in one buffer and yank it in another
buffer.  This is the usual way to move text from one file to another.
(*Note Accumulating Text::, for some other ways.)

   If you have two separate Emacs processes, you cannot use the kill
ring to move text. If you are using Lucid GNU Emacs under X, you can,
however, use the X selection mechanism to move text from one to
another.

   If you are using Lucid GNU Emacs under X and have one Emacs process
with multiple screens, they do share the same kill ring.  You can kill
or copy text in one Emacs screen, then yank it in the other screen
belonging to the same process.

   The command `C-y' (`yank') reinserts the text of the most recent
kill.  It leaves the cursor at the end of the text and sets the mark at
the beginning of the text.  *Note Mark::.

   `C-u C-y' yanks the text, leaves the cursor in front of the text,
and sets the mark after it, if the argument is with just a `C-u'.  Any
other argument, including `C-u' and digits, has different results,
described below, under "Yanking Earlier Kills".

   To copy a block of text, you can also use `M-w'
(`copy-region-as-kill'), which copies the region into the kill ring
without removing it from the buffer. `M-w' is similar to `C-w'
followed by `C-y' but does not mark the buffer as "modified" and does
not actually cut anything.


File: emacs,  Node: Appending Kills,  Next: Earlier Kills,  Prev: Kill Ring,  Up: Yanking

Appending Kills
---------------

   Normally, each kill command pushes a new block onto the kill ring.
However, two or more kill commands in a row combine their text into a
single entry, so that a single `C-y' yanks it all back. This means you
don't have to kill all the text you want to yank in one command; you
can kill line after line, or word after word, until you have killed
what you want, then get it all back at once using `C-y'. (Thus we join
television in leading people to kill thoughtlessly.)

   Commands that kill forward from point add onto the end of the
previous killed text.  Commands that kill backward from point add onto
the beginning.  This way, any sequence of mixed forward and backward
kill commands puts all the killed text into one entry without
rearrangement.  Numeric arguments do not break the sequence of
appending kills.  For example, suppose the buffer contains

     This is the first
     line of sample text
     and here is the third.

with point at the beginning of the second line.  If you type `C-k C-u 2
M-DEL C-k', the first `C-k' kills the text `line of sample text', `C-u
2 M-DEL' kills `the first' with the newline that followed it, and the
second `C-k' kills the newline after the second line.  The result is
that the buffer contains `This is and here is the third.' and a single
kill entry contains `the firstRETline of sample textRET'--all the
killed text, in its original order.

   If a kill command is separated from the last kill command by other
commands (not just numeric arguments), it starts a new entry on the
kill ring.  To force a kill command to append, first type the command
`C-M-w' (`append-next-kill'). `C-M-w' tells the following command, if
it is a kill command, to append the text it kills to the last killed
text, instead of starting a new entry.  With `C-M-w', you can kill
several separated pieces of text and accumulate them to be yanked back
in one place.


File: emacs,  Node: Earlier Kills,  Prev: Appending Kills,  Up: Yanking

Yanking Earlier Kills
---------------------

   To recover killed text that is no longer the most recent kill, you
need the `Meta-y' (`yank-pop') command.  You can use `M-y' only after
a `C-y' or another `M-y'.  It takes the text previously yanked and
replaces it with the text from an earlier kill.  To recover the text
of the next-to-the-last kill, first use `C-y' to recover the last
kill, then `M-y' to replace it with the previous kill.

   You can think in terms of a "last yank" pointer which points at an
item in the kill ring.  Each time you kill, the "last yank" pointer
moves to the new item at the front of the ring.  `C-y' yanks the item
which the "last yank" pointer points to.  `M-y' moves the "last yank"
pointer to a different item, and the text in the buffer changes to
match.  Enough `M-y' commands can move the pointer to any item in the
ring, so you can get any item into the buffer.  Eventually the pointer
reaches the end of the ring; the next `M-y' moves it to the first item
again.

   Yanking moves the "last yank" pointer around the ring, but does not
change the order of the entries in the ring, which always runs from the
most recent kill at the front to the oldest one still remembered.

   Use `M-y' with a numeric argument, to tell to advance the "last
yank" pointer by the specified number of items.  A negative argument
moves the pointer toward the front of the ring; from the front of the
ring, it moves to the last entry and starts moving forward from there.

   Once the text you are looking for is brought into the buffer, you
can stop doing `M-y' commands and the text will stay there. Since the
text is just a copy of the kill ring item, editing it in the buffer
does not change what's in the ring.  As long you don`t kill additional
text, the "last yank" pointer remains at the same place in the kill
ring: repeating `C-y' will yank another copy of the same old kill.

   If you know how many `M-y' commands it would take to find the text
you want, you can yank that text in one step using `C-y' with a
numeric argument.  `C-y' with an argument greater than one restores
the text the specified number of entries back in the kill ring.  Thus,
`C-u 2 C-y' gets the next to the last block of killed text.  It is
equivalent to `C-y M-y'.  `C-y' with a numeric argument starts
counting from the "last yank" pointer, and sets the "last yank"
pointer to the entry that it yanks.

   The variable `kill-ring-max' controls the length of the kill ring;
no more than that many blocks of killed text are saved.


File: emacs,  Node: Using X Selections,  Next: Accumulating Text,  Prev: Yanking,  Up: Top

Using X Selections
==================

   In the X window system, mouse selections provide a simple mechanism
for text transfer between different applications.  In a typical X
application, you can select text by pressing the left mouse button and
dragging the cursor over the text you want to copy. The text becomes
the primary X selection and is highlighted. The highlighted region is
also the Emacs selected region.

   * Since the region is the primary X selection, you can go to a
     different X application and click the middle mouse button: the
     text that you selected in the previous application is pasted into
     the current application.

   * Since the region is the Emacs selected region, you can use all
     region commands (`C-w, M-w' etc.) as well as the options of the
     Edit menu to manipulate the selected text.

* Menu:

* X Clipboard Selection::         Storing the primary selection.
* X Selection Commands::    Other operations on the selection.
* X Cut Buffers::           X cut buffers are available for compatibility.
* Active Regions::          Using zmacs-style highlighting of the
                             selected region.


File: emacs,  Node: X Clipboard Selection,  Next: X Selection Commands,  Prev: Using X Selections,  Up: Using X Selections

The Clipboard Selection
-----------------------

   There are other kinds of X selection besides the primary selection.
 Each time a region of text is added to the kill ring (for example,
with C-k, C-w, or M-w or with a Cut or Copy menu item), that text
becomes the clipboard selection.

   Usually, the clipboard selection is not visible. However, if you run
the `xclipboard' application, the most recently killed text--the value
of the clipboard selection--is displayed in a window.  Any time Emacs
adds text to the kill ring, the `xclipboard' application makes a copy
of it and displays it in its window. The value of the clipboard can
survive the lifetime of the running Emacs process. The `xclipboard'
man page provides more details.

   Warning: If you use the `xclipboard' application, remember that it
maintains a list of all things that have been pasted to the clipboard
(that is, killed in Emacs).  If you don't manually delete elements from
this list by clicking on the Delete button in the `xclipboard' window,
the clipboard will eventually consume a lot of memory.


File: emacs,  Node: X Selection Commands,  Next: X Cut Buffers,  Prev: X Clipboard Selection,  Up: Using X Selections

Miscellaneous X Selection Commands
----------------------------------

`M-x x-copy-primary-selection'
     Copy the primary selection to both the kill ring and the
     Clipboard.

`M-x x-insert-selection'
     Insert the current selection into the buffer at point.

`M-x x-delete-primary-selection'
     Deletes the text in the primary selection without copying it to
     the kill ring or the Clipboard.

`M-x x-kill-primary-selection'
     Deletes the text in the primary selection and copies it to both
     the kill ring and the Clipboard.

`M-x x-mouse-kill'
     Kill the text between point and the mouse and copy it to the
     clipboard and to the cut buffer.

`M-x x-new-screen'
     Create a new Emacs screen (that is, a new X window).

`M-x x-own-secondary-selection'
     Make a secondary X selection of the given argument.

`M-x x-own-selection'
     Make a primary X selection of the given argument.

`M-x x-set-point-and-insert-selection'
     Set point where clicked and insert the primary selection or the
     cut buffer.


File: emacs,  Node: X Cut Buffers,  Next: Active Regions,  Prev: X Selection Commands,  Up: Using X Selections

X Cut Buffers
-------------

   X cut buffers are a different, older way of transferring text
between applications.  Lucid GNU Emacs supports cut buffers for
compatibility with older programs, even though selections are now the
preferred way of transferring text.

   X has a concept of applications "owning" selections.  When you
select text by clicking and dragging inside an application, the
application tells the X server that it owns the selection.  When
another application asks the X server for the value of the selection,
the X server requests the information from the owner. When you use
selections, the selection data is not actually transferred unless
someone wants it; the act of making a selection doesn't transfer data.
Cut buffers are different: when you "own" a cut buffer, the data is
actually transferred to the X server immediately, and survives the
lifetime of the application.

   Any time a region of text becomes the primary selection in Emacs,
Emacs also copies that text to the cut buffer.  This makes it possible
to copy text from a Lucid GNU Emacs buffer and paste it into an older,
non-selection-based application (such as Emacs 18.)

   Note: Older versions of Emacs could not access the X selections,
only the X cut buffers.


File: emacs,  Node: Active Regions,  Prev: X Cut Buffers,  Up: Using X Selections

Active Regions
--------------

   By default, both the text you select in an Emacs buffer using the
click-and-drag mechanism and text you select by setting point and the
mark is highlighted. You can use Emacs region commands as well as the
Cut and Copy commands on the highlighted region you selected with the
mouse.

   If you prefer, you can make a distinction between text selected
with the mouse and text selected with point and the mark by setting
the variable `zmacs-regions' to `nil'.  In that case:

   * The text selected with the mouse becomes both the X selection and
     the Emacs selected region. You can use menubar commands as well
     as Emacs region commands on it.

   * The text selected with point and the mark does not highlight. You
     can only use Emacs region commands but not the menu bar items on
     it.

   Active regions originally come from Zmacs, the Lisp Machine editor.
The idea behind them is that commands can only operate on a region when
the region is in an "active" state.  Put simply, you can only operate
on a region that is highlighted.

   The variable `zmacs-regions' checks whether LISPM-style active
regions should be used.  This means that commands that operate on the
region (the area between point and the mark) only work while the
region is in the active state, which is indicated by highlighting.
Most commands causes the region to not be in the active state; for
example, `C-w' only works immediately after activating the region.

   More specifically:

   * Commands that operate on the region only work if the region is
     active.

   * Only a very small set of commands causes the region to become
     active-- those commands whose semantics are to mark an area, such
     as `mark-defun'.

   * The region is deactivated after each command that is executed,
     except that motion commands do not change whether the region is
     active or not.

   `set-mark-command' (`C-SPC') pushes a mark and activates the
region.  Moving the cursor with normal motion commands (`C-n', `C-p',
etc) will cause the region between point and the recently-pushed mark
to be highlighted.  It will remain highlighted until some non-motion
comand is executed.

   `exchange-point-and-mark' (`C-x C-x') activates the region.  So if
you mark a region and execute a command that operates on it, you can
reactivate the same region with `C-x C-x' (or perhaps `C-x C-x C-x
C-x') to operate on it again.

   Generally, commands that push marks as a means of navigation, such
as `beginning-of-buffer' (`M-<') and `end-of-buffer' (`M->'), do not
activate the region.  However, commands that push marks as a means of
marking an area of text, such as `mark-defun' (`M-C-h'), `mark-word'
(`M-@'), and `mark-whole-buffer' (`C-x h'), do activate the region.

   When `zmacs-regions' is `t', there is no distinction between the
primary X selection and the active region selected by point and the
mark.  To see this, set the mark (C-SPC) and move the cursor with any
cursor-motion command: the region between point and mark is
highlighted, and you can watch it grow and shrink as you move the
cursor.

   Any other commands besides cursor-motion commands (such as
inserting or deleting text) will cause the region to no longer be
active; it will no longer be highlighted, and will no longer be the
primary selection.  Errors also remove highlighting from a region.

   Commands which require a region (such as `C-w') signal an error if
the region is not active.  Certain commands cause the region to be in
its active state.  The most common ones are `push-mark' (C-SPC) and
`exchange-point-and-mark' (`C-x C-x').

   When `zmacs-regions' is `t', programs can be non-intrusive on the
state of the region by setting the variable `zmacs-region-stays' to a
non-`nil' value.  If you are writing a new emacs command that is
conceptually a "motion" command, and should not interfere with the
current highlightedness of the region, then you may set this variable.
It is reset to `nil' after each user command is executed.

   When `zmacs-regions' is `t', programs can make the region between
point and mark go into the active (highlighted) state by using the
function `zmacs-activate-region'. Only a small number of commands
should ever do this.

   When `zmacs-regions' is `t', programs can deactivate the region
between point and the mark by using `zmacs-deactivate-region'.  Note:
you should not have to call this function; the command loop calls it
when appropriate.


File: emacs,  Node: Accumulating Text,  Next: Rectangles,  Prev: Using X Selections,  Up: Top

Accumulating Text
=================

   Usually you copy or move text by killing it and yanking it, but
there are other ways that are useful for copying one block of text in
many places, or for copying many scattered blocks of text into one
place.

   If you like, you can accumulate blocks of text from scattered
locations either into a buffer or into a file.  The relevant commands
are described here.  You can also use Emacs registers for storing and
accumulating text.  *Note Registers::.

`C-x a'
     Append region to contents of specified buffer
     (`append-to-buffer').

`M-x prepend-to-buffer'
     Prepend region to contents of specified buffer.

`M-x copy-to-buffer'
     Copy region into specified buffer, deleting that buffer's old
     contents.

`M-x insert-buffer'
     Insert contents of specified buffer into current buffer at point.

`M-x append-to-file'
     Append region to contents of specified file, at the end.

   To accumulate text into a buffer, use the command `C-x a
BUFFERNAME' (`append-to-buffer'), which inserts a copy of the region
into the buffer BUFFERNAME, at the location of point in that buffer.
If there is no buffer with the given name, one is created.

   If you append text to a buffer that has been used for editing, the
copied text goes to the place where point is.  Point in that buffer is
left at the end of the copied text, so successive uses of `C-x a'
accumulate the text in the specified buffer in the same order as they
were copied.  Strictly speaking, `C-x a' does not always append to the
text already in the buffer; but if `C-x a' is the only command used to
alter a buffer, it does always append to the existing text because
point is always at the end.

   `M-x prepend-to-buffer' is similar to `C-x a' but point in the
other buffer is left before the copied text, so successive prependings
add text in reverse order.  `M-x copy-to-buffer' is similar except that
any existing text in the other buffer is deleted, so the buffer is left
containing just the text newly copied into it.

   You can retrieve the accumulated text from that buffer with `M-x
insert-buffer', which takes BUFFERNAME as an argument.  It inserts a
copy of the text in buffer BUFFERNAME into the selected buffer.  You
could alternatively select the other buffer for editing, perhaps moving
text from it by killing or with `C-x a'.  *Note Buffers::, for
background information on buffers.

   Instead of accumulating text within Emacs, in a buffer, you can
append text directly into a file with `M-x append-to-file', which takes
FILE-NAME as an argument.  It adds the text of the region to the end
of the specified file.  The file is changed immediately on disk.  This
command is normally used with files that are not being visited in
Emacs.  Using it on a file that Emacs is visiting can produce
confusing results, because the file's text inside Emacs does not change
while the file itself changes.


File: emacs,  Node: Rectangles,  Next: Registers,  Prev: Accumulating Text,  Up: Top

Rectangles
==========

   The rectangle commands affect rectangular areas of text: all
characters between a certain pair of columns, in a certain range of
lines.  Commands are provided to kill rectangles, yank killed
rectangles, clear them out, or delete them.  Rectangle commands are
useful with text in multicolumnar formats, like code with comments at
the right, or for changing text into or out of such formats.

   To specify the rectangle a command should work on, put the mark at
one corner and point at the opposite corner.  The specified rectangle
is called the "region-rectangle" because it is controlled about the
same way the region is controlled.  Remember that a given combination
of point and mark values can be interpreted either as specifying a
region or as specifying a rectangle; it is up to the command that uses
them to choose the interpretation.

`M-x delete-rectangle'
     Delete the text of the region-rectangle, moving any following
     text on each line leftward to the left edge of the
     region-rectangle.

`M-x kill-rectangle'
     Similar, but also save the contents of the region-rectangle as the
     "last killed rectangle".

`M-x yank-rectangle'
     Yank the last killed rectangle with its upper left corner at
     point.

`M-x open-rectangle'
     Insert blank space to fill the space of the region-rectangle.
     The previous contents of the region-rectangle are pushed
     rightward.

`M-x clear-rectangle'
     Clear the region-rectangle by replacing its contents with spaces.

   The rectangle operations fall into two classes: commands deleting
and moving rectangles, and commands for blank rectangles.

   There are two ways to get rid of the text in a rectangle: you can
discard the text (delete it) or save it as the "last killed"
rectangle.  The commands for these two ways are `M-x delete-rectangle'
and `M-x kill-rectangle'.  In either case, the portion of each line
that falls inside the rectangle's boundaries is deleted, causing
following text (if any) on the line to move left.

   Note that "killing" a rectangle is not killing in the usual sense;
the rectangle is not stored in the kill ring, but in a special place
that only records the most recently killed rectangle (that is, does not
append to a killed rectangle).  Different yank commands have to be
used and only one rectangle is stored because yanking a rectangle is
quite different from yanking linear text and yank-popping commands are
difficult to make sense of.

   Inserting a rectangle is the opposite of deleting one.  You specify
where to put the upper left corner by putting point there.  The
rectangle's first line is inserted at point, the rectangle's second
line is inserted at a point one line vertically down, and so on.  The
number of lines affected is determined by the height of the saved
rectangle.

   To insert the last killed rectangle, type `M-x yank-rectangle'.
This can be used to convert single-column lists into double-column
lists; kill the second half of the list as a rectangle and then yank
it beside the first line of the list.

   There are two commands for working with blank rectangles: `M-x
clear-rectangle' to blank out existing text, and `M-x open-rectangle'
to insert a blank rectangle.  Clearing a rectangle is equivalent to
deleting it and then inserting a blank rectangle of the same size.

   Rectangles can also be copied into and out of registers.  *Note
Rectangle Registers: RegRect.


File: emacs,  Node: Registers,  Next: Display,  Prev: Rectangles,  Up: Top

Registers
*********

   Emacs "registers" are places in which you can save text or
positions for later use.  Text saved in a register can be copied into
the buffer once or many times; a position saved in a register is used
by moving point to that position.  Rectangles can also be copied into
and out of registers (*note Rectangles::.).

   Each register has a name, which is a single character.  A register
can store either a piece of text or a position or a rectangle, but
only one thing at any given time.  Whatever you store in a register
remains there until you store something else in that register.

* Menu:

* RegPos::    Saving positions in registers.
* RegText::   Saving text in registers.
* RegRect::   Saving rectangles in registers.

`M-x view-register RET R'
     Display a description of what register R contains.

   `M-x view-register' reads a register name as an argument and then
displays the contents of the specified register.


File: emacs,  Node: RegPos,  Next: RegText,  Prev: Registers,  Up: Registers

Saving Positions in Registers
=============================

   Saving a position records a spot in a buffer so you can move back
there later.  Moving to a saved position re-selects the buffer and
moves point to the spot.

`C-x / R'
     Save the location of point in register R (`point-to-register').

`C-x j R'
     Jump to the location saved in register R (`register-to-point').

   To save the current location of point in a register, choose a name
R and type `C-x / R'.  The register R retains the location thus saved
until you store something else in that register.

   The command `C-x j R' moves point to the location recorded in
register R.  The register is not affected; it continues to record the
same location.  You can jump to the same position using the same
register as often as you want.


File: emacs,  Node: RegText,  Next: RegRect,  Prev: RegPos,  Up: Registers

Saving Text in Registers
========================

   When you want to insert a copy of the same piece of text many
times, it can be impractical to use the kill ring, since each
subsequent kill moves the piece of text further down on the ring.  It
becomes hard to keep track of the argument needed to retrieve the same
text with `C-y'.  An alternative is to store the text in a register
with `C-x x' (`copy-to-register') and then retrieve it with `C-x g'
(`insert-register').

`C-x x R'
     Copy region into register R (`copy-to-register').

`C-x g R'
     Insert text contents of register R (`insert-register').

   `C-x x R' stores a copy of the text of the region into the register
named R.  Given a numeric argument, `C-x x' deletes the text from the
buffer as well.

   `C-x g R' inserts the text from register R in the buffer.  By
default it leaves point before the text and places the mark after it.
With a numeric argument, it puts point after the text and the mark
before it.


File: emacs,  Node: RegRect,  Prev: RegText,  Up: Registers

Saving Rectangles in Registers
==============================

   A register can contain a rectangle instead of lines of text.  The
rectangle is represented as a list of strings.  *Note Rectangles::,
for basic information on rectangles and how to specify rectangles in a
buffer.

`C-x r R'
     Copy the region-rectangle into register
     R(`copy-region-to-rectangle').  With a numeric argument, delete
     it as well.

`C-x g R'
     Insert the rectangle stored in register R (if it contains a
     rectangle) (`insert-register').

   The `C-x g' command inserts linear text if the register contains
that, or inserts a rectangle if the register contains one.


File: emacs,  Node: Display,  Next: Search,  Prev: Registers,  Up: Top

Controlling the Display
***********************

   Since only part of a large buffer fits in the window, Emacs tries
to show the part that is likely to be interesting.  The display
control commands allow you to specify which part of the text you want
to see.

`C-l'
     Clear screen and redisplay, scrolling the selected window to
     center point vertically within it (`recenter').

`C-v'
     Scroll forward (a windowful or a specified number of lines)
     (`scroll-up').

`M-v'
     Scroll backward (`scroll-down').

`ARG C-l'
     Scroll so point is on line ARG (`recenter').

`C-x <'
     Scroll text in current window to the left (`scroll-left').

`C-x >'
     Scroll to the right (`scroll-right').

`C-x $'
     Make deeply indented lines invisible (`set-selective-display').

* Menu:

* Scrolling::               Moving text up and down in a window.
* Horizontal Scrolling::   Moving text left and right in a window.
* Selective Display::      Hiding lines with lots of indentation.
* Display Vars::           Information on variables for customizing display.


File: emacs,  Node: Scrolling,  Next: Horizontal Scrolling,  Prev: Display,  Up: Display

Scrolling
=========

   If a buffer contains text that is too large to fit entirely within
the window that is displaying the buffer, Emacs shows a contiguous
section of the text.  The section shown always contains point.

   "Scrolling" means moving text up or down in the window so that
different parts of the text are visible.  Scrolling forward means that
text moves up, and new text appears at the bottom.  Scrolling backward
moves text down and new text appears at the top.

   Scrolling happens automatically if you move point past the bottom
or top of the window.  You can also explicitly request scrolling with
the commands in this section.

`C-l'
     Clear screen and redisplay, scrolling the selected window to
     center point vertically within it (`recenter').

`C-v'
     Scroll forward (a windowful or a specified number of lines)
     (`scroll-up').

`M-v'
     Scroll backward (`scroll-down').

`ARG C-l'
     Scroll so point is on line ARG (`recenter').

   The most basic scrolling command is `C-l' (`recenter') with no
argument.  It clears the entire screen and redisplays all windows.  In
addition, it scrolls the selected window so that point is halfway down
from the top of the window.

   The scrolling commands `C-v' and `M-v' let you move all the text in
the window up or down a few lines.  `C-v' (`scroll-up') with an
argument shows you that many more lines at the bottom of the window,
moving the text and point up together as `C-l' might.  `C-v' with a
negative argument shows you more lines at the top of the window.
`Meta-v' (`scroll-down') is like `C-v', but moves in the opposite
direction.

   To read the buffer a windowful at a time, use `C-v' with no
argument.  `C-v' takes the last two lines at the bottom of the window
and puts them at the top, followed by nearly a whole windowful of
lines not previously visible.  Point moves to the new top of the window
if it was in the text scrolled off the top.  `M-v' with no argument
moves backward with similar overlap.  The number of lines of overlap
across a `C-v' or `M-v' is controlled by the variable
`next-screen-context-lines'; by default, it is two.

   Another way to scroll is using `C-l' with a numeric argument.
`C-l' does not clear the screen when given an argument; it only
scrolls the selected window.  With a positive argument N,`C-l'
repositions text to put point N lines down from the top.  An argument
of zero puts point on the very top line.  Point does not move with
respect to the text; rather, the text and point move rigidly on the
screen.  `C-l' with a negative argument puts point that many lines
from the bottom of the window.  For example, `C-u - 1 C-l' puts point
on the bottom line, and `C-u - 5 C-l' puts it five lines from the
bottom.  Just `C-u' as argument, as in `C-u C-l', scrolls point to the
center of the screen.

   Scrolling happens automatically if point has moved out of the
visible portion of the text when it is time to display.  Usually
scrolling is done  to put point vertically centered within the window.
 However, if the variable `scroll-step' has a non-zero value, an
attempt is made to scroll the buffer by that many lines; if that is
enough to bring point back into visibility, that is what happens.


File: emacs,  Node: Horizontal Scrolling,  Prev: Scrolling,  Up: Display

Horizontal Scrolling
====================

`C-x <'
     Scroll text in current window to the left (`scroll-left').

`C-x >'
     Scroll to the right (`scroll-right').

   The text in a window can also be scrolled horizontally.  This means
that each line of text is shifted sideways in the window, and one or
more characters at the beginning of each line are not displayed at
all.  When a window has been scrolled horizontally in this way, text
lines are truncated rather than continued (*note Continuation
Lines::.), with a `$' appearing in the first column when there is text
truncated to the left, and in the last column when there is text
truncated to the right.

   The command `C-x <' (`scroll-left') scrolls the selected window to
the left by N columns with argument N.  With no argument, it scrolls
by almost the full width of the window (two columns less, to be
precise).  `C-x >' (`scroll-right') scrolls similarly to the right.
The window cannot be scrolled any farther to the right once it is
displaying normally (with each line starting at the window's left
margin); attempting to do so has no effect.


File: emacs,  Node: Selective Display,  Next: Display Vars,  Prev: Display,  Up: Display

Selective Display
=================

   Emacs can hide lines indented more than a certain number of columns
(you specify how many columns).  This allows you  to get an overview
of a part of a program.

   To hide lines, type `C-x $' (`set-selective-display') with a
numeric argument N.  (*Note Arguments::, for information on giving the
argument.)  Lines with at least N columns of indentation disappear
from the screen.  The only indication of their presence are three dots
(`...'), which appear at the end of each visible line that is followed
by one or more invisible ones.

   The invisible lines are still present in the buffer, and most
editing commands see them as usual, so it is very easy to put point in
the middle of invisible text.  When this happens, the cursor appears
at the end of the previous line, after the three dots.  If point is at
the end of the visible line, before the newline that ends it, the
cursor appears before the three dots.

   The commands `C-n' and `C-p' move across the invisible lines as if
they were not there.

   To make everything visible again, type `C-x $' with no argument.


File: emacs,  Node: Display Vars,  Prev: Selective Display,  Up: Display

Variables Controlling Display
=============================

   This section contains information for customization only.  Beginning
users should skip it.

   The variable `mode-line-inverse-video' controls whether the mode
line is displayed in inverse video (assuming the terminal supports it);
`nil' means don't do so.  *Note Mode Line::.

   If the variable `inverse-video' is non-`nil', Emacs attempts to
invert all the lines of the display from what they normally are.

   When you reenter Emacs after suspending, Emacs normally clears the
screen and redraws the entire display.  On some terminals with more
than one page of memory, it is possible to arrange the termcap entry
so that the `ti' and `te' strings (output to the terminal when Emacs
is entered and exited, respectively) switch between pages of memory so
as to use one page for Emacs and another page for other output.  In
that case, you might want to set the variable `no-redraw-on-reenter'
non-`nil' so that Emacs will assume, when resumed, that the screen
page it is using still contains what Emacs last wrote there.

   The variable `echo-keystrokes' controls the echoing of
multi-character keys; its value is the number of seconds of pause
required to cause echoing to start, or zero meaning don't echo at all.
 *Note Echo Area::.

   If the variable `ctl-arrow' is `nil', control characters in the
buffer are displayed with octal escape sequences, all except newline
and tab.  If its value is `t', then control characters will be printed
with an uparrow, for example `^A'.

   If its value is not `t' and not `nil', then characters whose code
is greater than 160 (that is, the space character (32) with its high
bit set) will be assumed to be printable, and will be displayed
without alteration.  This is the default when running under X Windows,
since Lucid Emacs assumes an ISO/8859-1 character set (also known as
"Latin1").  The `ctl-arrow' variable may also be set to an integer, in
which case all characters whose codes are greater than or equal to
that value will be assumed to be printable.

   Altering the value of `ctl-arrow' makes it local to the current
buffer; until that time, the default value is in effect.  *Note
Locals::.

   Normally, a tab character in the buffer is displayed as whitespace
which extends to the next display tab stop position, and display tab
stops come at intervals equal to eight spaces.  The number of spaces
per tab is controlled by the variable `tab-width', which is made local
by changing it, just like `ctl-arrow'.  Note that how the tab character
in the buffer is displayed has nothing to do with the definition of
TAB as a command.

   If you set the variable `selective-display-ellipses' to `nil', the
three dots at the end of a line that precedes invisible lines do not
appear.  There is no visible indication of the invisible lines.  This
variable becomes local automatically when set.


File: emacs,  Node: Search,  Next: Fixit,  Prev: Display,  Up: Top

Searching and Replacement
*************************

   Like other editors, Emacs has commands for searching for
occurrences of a string.  The principal search command is unusual in
that it is "incremental": it begins to search before you have finished
typing the search string.  There are also non-incremental search
commands more like those of other editors.

   Besides the usual `replace-string' command that finds all
occurrences of one string and replaces them with another, Emacs has a
fancy replacement command called `query-replace' which asks
interactively which occurrences to replace.

* Menu:

* Incremental Search::     Search happens as you type the string.
* Non-Incremental Search::  Specify entire string and then search.
* Word Search::            Search for sequence of words.
* Regexp Search::          Search for match for a regexp.
* Regexps::                Syntax of regular expressions.
* Search Case::            To ignore case while searching, or not.
* Replace::                Search, and replace some or all matches.
* Other Repeating Search:: Operating on all matches for some regexp.